Robotique à typage sûr : Améliorer le contrôle des robots avec des implémentations de types robustes

Le domaine de la robotique progresse rapidement, les robots devenant de plus en plus sophistiqués et intégrés dans des secteurs critiques tels que la fabrication, la santé, la logistique et le transport autonome. À mesure que les robots assument des tâches plus complexes et fonctionnent dans des environnements dynamiques et imprévisibles, il devient primordial de garantir la fiabilité, la sécurité et la prévisibilité de leurs systèmes de contrôle. Les pratiques traditionnelles de développement de logiciels sont souvent insuffisantes pour faire face aux complexités inhérentes et aux exigences strictes des applications robotiques. C'est là que la robotique à typage sûr émerge comme un paradigme crucial, se concentrant sur des implémentations de types robustes pour prévenir les erreurs au moment de la compilation et améliorer l'intégrité globale du système.

Cet article de blog complet examinera les concepts fondamentaux de la robotique à typage sûr, explorera diverses stratégies d'implémentation de types et discutera de leur impact sur les systèmes de contrôle de robots. Nous examinerons les avantages de l'adoption d'approches à typage sûr, mettrons en évidence les défis courants et fournirons des informations exploitables pour les développeurs qui souhaitent créer des systèmes robotiques plus fiables pour un public mondial.

L'impératif de fiabilité dans le contrôle des robots

Les systèmes de contrôle de robots sont des éléments logiciels complexes chargés de traduire les commandes de haut niveau en actions physiques précises. Ils impliquent la gestion des données des capteurs, l'exécution d'algorithmes complexes et l'interaction avec les actionneurs en temps réel. Dans les applications critiques pour la sécurité, un seul défaut logiciel peut entraîner des défaillances catastrophiques, entraînant des dommages matériels, des dommages environnementaux, voire des pertes de vies humaines. Considérez ces scénarios mondiaux :

• Automatisation de la fabrication : Les robots sur les chaînes de montage dans les usines automobiles en Allemagne, les usines d'électronique en Corée du Sud ou les installations de transformation des aliments au Brésil doivent fonctionner avec une extrême précision. Toute erreur de contrôle pourrait entraîner des produits endommagés, des temps d'arrêt de la production ou des blessures graves aux travailleurs humains partageant l'espace de travail.
• Robotique médicale : Les robots chirurgicaux utilisés dans les hôpitaux du monde entier, des centres médicaux avancés aux États-Unis aux cliniques isolées en Afrique, nécessitent une précision de contrôle absolue. Des dysfonctionnements pendant la chirurgie pourraient avoir des conséquences désastreuses pour les patients.
• Véhicules autonomes : Les voitures autonomes et les robots de livraison opérant dans divers environnements urbains et ruraux du monde entier, des rues animées de Tokyo aux autoroutes d'Australie, s'appuient sur des systèmes de contrôle sophistiqués. Les défaillances peuvent entraîner des accidents aux conséquences considérables.
• Robots d'exploration : Les rovers explorant Mars ou les submersibles en haute mer utilisés pour la recherche scientifique dans les océans du monde opèrent dans des environnements où l'intervention humaine est impossible. Leurs systèmes de contrôle doivent être exceptionnellement robustes pour assurer le succès de la mission et prévenir la perte irréversible de données ou l'endommagement de l'équipement.

Ces exemples soulignent le besoin urgent de méthodologies de développement logiciel qui atténuent de manière proactive les erreurs. Les langages de typage dynamique traditionnels, tout en offrant une certaine flexibilité, peuvent introduire des erreurs d'exécution difficiles à détecter et à déboguer, en particulier dans les systèmes robotiques complexes et distribués. Le typage statique, pierre angulaire de la programmation à typage sûr, offre un mécanisme puissant pour détecter de nombreuses erreurs avant même l'exécution du code.

Comprendre la sécurité des types dans l'ingénierie logicielle

La sécurité des types, dans le contexte des langages de programmation, fait référence à la mesure dans laquelle un langage empêche ou décourage les erreurs de type. Une erreur de type se produit lorsqu'une opération est appliquée à une valeur d'un type inapproprié. Par exemple, tenter d'ajouter une chaîne à un entier sans conversion explicite, ou traiter une lecture de capteur comme un signal de commande.

Un langage à typage sûr garantit que les opérations ne seront effectuées que sur des valeurs de types compatibles. Ceci est généralement réalisé grâce à un système de types, qui définit des règles pour la façon dont les types peuvent être utilisés et comment ils interagissent. Les systèmes de types peuvent être :

• Statique : Les types sont vérifiés au moment de la compilation. Cela signifie que la plupart des erreurs de type sont détectées avant l'exécution du programme, ce qui réduit considérablement la probabilité de défaillances d'exécution. Les langages comme Java, C++, Rust et Haskell utilisent le typage statique.
• Dynamique : Les types sont vérifiés au moment de l'exécution. Cela offre une plus grande flexibilité, mais transfère la charge de la vérification des types au programmeur et à l'environnement d'exécution, augmentant ainsi le risque d'erreurs de type d'exécution. Les langages comme Python, JavaScript et Ruby sont typés dynamiquement.

Pour la robotique, où la fiabilité et la sécurité sont primordiales, le typage statique est généralement préféré. Il offre une garantie de correction plus forte et permet une détection précoce des problèmes potentiels, ce qui est précieux dans le développement de logiciels de contrôle complexes et critiques pour la sécurité.

Stratégies d'implémentation de types dans le contrôle des robots

La mise en œuvre de la sécurité des types dans le contrôle des robots implique une approche à multiples facettes, tirant parti des capacités des langages de programmation et des outils de développement modernes. L'objectif est de définir des types clairs et non ambigus pour toutes les données et opérations au sein de la pile logicielle du robot, des interfaces de capteurs de bas niveau aux modules de prise de décision de haut niveau.

1. Typage statique fort avec des structures de données bien définies

La base de la robotique à typage sûr réside dans l'utilisation de langages de programmation avec un typage statique fort et la définition méticuleuse des structures de données. Cela signifie déclarer explicitement le type de chaque variable, paramètre et valeur de retour.

Types primitifs et leurs limites

Les types de base comme les entiers, les nombres à virgule flottante et les booléens sont fondamentaux. Cependant, leur utilisation en robotique nécessite un examen attentif :

• Dépassement/Sous-dépassement d'entier : Lors de la gestion des lectures de capteurs ou des positions d'actionneurs, l'utilisation d'entiers de taille fixe peut entraîner un dépassement ou un sous-dépassement si les valeurs dépassent la plage définie. Par exemple, un entier de 16 bits ne peut représenter que des valeurs jusqu'à 32 767. Si une lecture de capteur dépasse cette valeur, la valeur est bouclée, ce qui entraîne des données incorrectes. Les développeurs doivent choisir des tailles d'entier appropriées (par exemple, 32 bits, 64 bits) ou utiliser des bibliothèques qui fournissent une arithmétique de précision arbitraire si nécessaire.
• Précision à virgule flottante : Les nombres à virgule flottante (par exemple, `float`, `double`) sont essentiels pour représenter des quantités physiques continues comme la vitesse, la position ou les forces. Cependant, ils ont des limitations de précision inhérentes et peuvent souffrir d'erreurs d'arrondi, en particulier dans les calculs itératifs. Cela peut s'accumuler avec le temps et entraîner une dérive du comportement du robot. Des techniques telles que l'utilisation de `double` plutôt que `float` pour les calculs critiques, ou l'utilisation d'une arithmétique à virgule fixe lorsque cela est possible, peuvent atténuer ces problèmes.

Types de données structurées pour une représentation plus riche

Au-delà des primitives, l'utilisation de types de données structurées offre un moyen plus expressif et sûr de représenter des informations complexes :

• Structs/Records : Le regroupement de données connexes dans des structures améliore la lisibilité et la maintenabilité. Par exemple, une structure `RobotPose` pourrait encapsuler les données de position (x, y, z) et d'orientation (roulis, tangage, lacet), garantissant que ces composants sont toujours traités ensemble.
• Enums (énumérations) : Les énumérations sont précieuses pour représenter des états discrets ou des types de commandes. Au lieu d'utiliser des entiers arbitraires pour représenter les modes de robot (par exemple, `0` pour `IDLE`, `1` pour `MOVING`, `2` pour `ERROR`), une énumération fournit des constantes nommées qui sont plus auto-documentées et empêchent une utilisation abusive accidentelle. Par exemple, une énumération `RobotState` serait beaucoup plus sûre que l'utilisation de nombres magiques.
• Classes et objets (programmation orientée objet) : Dans les langages OOP, les classes peuvent définir des plans pour les composants du robot, encapsulant à la fois les données (attributs) et le comportement (méthodes). Cela favorise la modularité et permet des interfaces claires entre les différentes parties du système de contrôle du robot.

Exemple : Dans un système de coordination multi-robots pour l'automatisation d'entrepôt, la définition d'une structure `RobotCommand` avec des champs pour `robot_id`, `command_type` (une énumération comme `MOVE_TO_LOCATION`, `PICK_UP_ITEM`, `RETURN_TO_BASE`) et `parameters` (qui pourrait être une autre structure ou un type variant en fonction de la commande) garantit que les commandes sont bien formées et non ambiguës.

2. Types d'unité et types spécifiques au domaine

Une avancée significative dans la sécurité des types est l'introduction de types d'unité et de types spécifiques au domaine qui encodent les unités physiques et les contraintes directement dans le système de types.

Types d'unité

Les langages de programmation traditionnels traitent tous les nombres du même type primitif de manière identique, quelle que soit leur signification physique. Les types d'unité, pris en charge par des langages comme F# et de plus en plus explorés dans la recherche et les bibliothèques spécialisées pour C++ et Rust, vous permettent d'attacher des unités physiques (par exemple, mètres, secondes, kilogrammes, radians) aux valeurs numériques.

Avantages :

• Empêche les incompatibilités d'unités : Le compilateur peut détecter les erreurs comme l'ajout de mètres à des secondes, ou la multiplication de la vitesse (m/s) par l'accélération (m/s²) et s'attendre à un résultat en mètres.
• Améliore la lisibilité du code : Les unités sont explicites dans la signature du type, ce qui rend l'intention du code plus claire.
• Réduit les erreurs de conversion : Les conversions d'unités manuelles sont une source courante de bogues. Les types d'unité automatisent ou au moins mettent en évidence ces opérations.

Exemple :

            
// Syntaxe hypothétique utilisant des types d'unité

function calculate_distance(speed: MetersPerSecond, time: Seconds) -> Meters {
    return speed * time;
}

let my_speed: MetersPerSecond = 10.0;
let my_time: Seconds = 5.0;
let distance: Meters = calculate_distance(my_speed, my_time);

// Erreur : Impossible d'appeler calculate_distance avec Seconds et Meters
// let invalid_distance = calculate_distance(my_time, my_speed);

            

              
                Copy
              
            
          

Bien que la prise en charge complète des types d'unité ne soit pas omniprésente dans les langages grand public, des bibliothèques et des frameworks émergent qui offrent des capacités de vérification au moment de la compilation similaires. Par exemple, les bibliothèques en C++ et Rust peuvent aider à appliquer la cohérence dimensionnelle.

Types spécifiques au domaine (modélisation du domaine)

Au-delà des unités physiques, vous pouvez définir des types qui représentent des concepts spécifiques au sein du domaine de la robotique. Cela implique la création de types qui encapsulent la sémantique des données.

• `Position` vs. `Velocity` vs. `Acceleration` : Même s'ils sont tous représentés par des nombres à virgule flottante, des types distincts garantissent qu'ils ne sont pas mélangés.
• `JointAngle` vs. `CartesianCoordinate` : Différentes représentations des informations spatiales doivent avoir des types distincts.
• `GripperCommand` vs. `MotorCommand` : Les commandes pour différents actionneurs ou sous-systèmes doivent être distinguables.

Exemple : Dans un bras de robot industriel, vous pouvez définir des types tels que :

            
struct JointAngle {
    value_rad: f64; // Angle en radians
}

struct CartesianPosition {
    x: f64; // Mètres
    y: f64; // Mètres
    z: f64; // Mètres
}

struct GripperState {
    is_open: bool;
    force_newtons: f64;
}

function move_arm_to(target_position: CartesianPosition);
function set_gripper_state(state: GripperState);

            

              
                Copy
              
            
          

Cette approche rend l'intention du code explicite et permet au compilateur de détecter les erreurs comme le passage d'un `JointAngle` là où un `CartesianPosition` est attendu.

3. Fonctionnalités avancées du système de types

Les langages de programmation modernes offrent des fonctionnalités avancées qui peuvent améliorer davantage la sécurité des types en robotique :

• Types de données algébriques (ADT) et correspondance de motifs : Les langages comme Rust et Haskell fournissent des ADT (qui incluent des énumérations avec des données associées et des structures) et une correspondance de motifs puissante. Ceci est extrêmement utile pour gérer différents états ou types de messages de manière robuste.

Exemple : Gestion de différents types de lectures de capteurs :

            
enum SensorReading {
    Temperature(celsius: f32),
    Pressure(pascals: f32),
    Distance(meters: f32),
    Status(code: u16, message: String),
}

fn process_reading(reading: SensorReading) {
    match reading {
        SensorReading::Temperature(temp) => {
            println!("Temperature: {}", temp);
        },
        SensorReading::Pressure(pressure) => {
            println!("Pressure: {}", pressure);
        },
        SensorReading::Distance(dist) => {
            println!("Distance: {}", dist);
        },
        SensorReading::Status(code, msg) => {
            println!("Status {}: {}", code, msg);
        }
    }
}

            

              
                Copy
              
            
          

Cela garantit que tous les types de lectures de capteurs possibles sont gérés explicitement. Le compilateur signalera une erreur si une nouvelle variante `SensorReading` est ajoutée mais n'est pas gérée dans l'instruction `match`.

• Génériques et polymorphisme : Les génériques vous permettent d'écrire du code qui peut fonctionner sur des valeurs de différents types, tout en garantissant la sécurité des types. Ceci est crucial pour créer des composants réutilisables, tels que des structures de données ou des algorithmes, qui peuvent être adaptés à divers types de données sans sacrifier la vérification des types.

Exemple : Une file d'attente générique qui peut contenir n'importe quel type :

            
struct Queue<T> {
    elements: Vec<T>;
}

impl<T> Queue<T> {
    fn new() -> Self {
        Queue { elements: Vec::new() }
    }

    fn enqueue(&mut self, item: T) {
        self.elements.push(item);
    }

    fn dequeue(&mut self) -> Option<T> {
        if self.elements.is_empty() {
            None
        } else {
            Some(self.elements.remove(0))
        }
    }
}

// Utilisation :
let mut int_queue: Queue<i32> = Queue::new();
int_queue.enqueue(10);
let first_int = int_queue.dequeue(); // Option<i32>

let mut pose_queue: Queue<CartesianPosition> = Queue::new();
pose_queue.enqueue(CartesianPosition { x: 1.0, y: 2.0, z: 0.5 });
let first_pose = pose_queue.dequeue(); // Option<CartesianPosition>

// Erreur : Impossible de mettre i32 dans une Queue<CartesianPosition>
// pose_queue.enqueue(10);

            

              
                Copy
              
            
          

Les génériques permettent de créer des bibliothèques et des frameworks flexibles pour la robotique qui peuvent être utilisés dans différents projets et plates-formes robotiques sans compromettre la sécurité des types.

4. Outils de vérification formelle et d'analyse statique

Bien que les systèmes de types détectent de nombreuses erreurs, certains bogues subtils peuvent encore passer à travers. Les méthodes de vérification formelle et les outils d'analyse statique jouent un rôle complémentaire pour garantir la sécurité des types et la correction globale du système.

• Outils d'analyse statique : Les outils comme les linters (par exemple, `clippy` pour Rust), les compilateurs avec des niveaux d'avertissement stricts et les suites d'analyse statique dédiées (par exemple, PVS-Studio, Coverity) peuvent détecter un large éventail de problèmes potentiels, y compris les violations des normes de codage, les erreurs d'exécution potentielles et les vulnérabilités de sécurité, dont beaucoup sont liées à une mauvaise utilisation des types.
• Model Checking : Cette technique consiste à créer un modèle formel du système et à explorer tous les chemins d'exécution possibles pour identifier les erreurs potentielles, y compris les conditions de concurrence, les blocages et les incohérences d'état, qui peuvent être des conséquences indirectes de problèmes liés aux types.
• Assistants de preuve et prouveurs de théorèmes : Pour les systèmes extrêmement critiques, des méthodes formelles peuvent être utilisées pour prouver mathématiquement l'exactitude de certaines propriétés. Cela implique d'écrire des spécifications en logique formelle et d'utiliser des assistants de preuve (par exemple, Coq, Isabelle) pour vérifier que le code respecte ces spécifications. Bien que complexe et chronophage, cela offre le plus haut niveau d'assurance.

Exemple : Dans les systèmes de conduite autonome, la vérification formelle pourrait être utilisée pour prouver que le système d'évitement de collision s'activera toujours dans des conditions spécifiques, quels que soient le bruit du capteur ou les retards de calcul mineurs. Cela implique souvent de définir les transitions d'état et les propriétés à l'aide de la logique formelle, puis d'utiliser des outils pour vérifier ces propriétés par rapport à la conception ou à la mise en œuvre du système.

5. Choix du langage et de l'écosystème

Le choix du langage de programmation et de son écosystème associé a un impact significatif sur la facilité et l'efficacité de la mise en œuvre de la robotique à typage sûr.

• Rust : Souvent cité comme un excellent candidat pour la programmation système, Rust offre un typage statique fort, un système de types puissant avec des ADT et des traits, des garanties de sécurité de la mémoire sans collecteur d'ordures (essentiel pour les systèmes temps réel) et d'excellentes performances. Son écosystème en croissance pour les systèmes embarqués et la robotique en fait un choix attrayant. Des bibliothèques comme `nalgebra` pour l'algèbre linéaire et `uom` pour la gestion des unités démontrent des approches à typage sûr robustes.
• C++ avec les normes modernes : Bien que C++ ait une longue histoire dans la robotique, ses anciennes versions peuvent être sujettes aux erreurs de type. Cependant, le C++ moderne (C++11, C++14, C++17, C++20 et au-delà) avec sa métaprogrammation de modèles, `std::variant`, `std::any` et une forte déduction de type, offre des améliorations significatives. Les bibliothèques pour les systèmes d'unités et une gestion de la mémoire plus sûre (par exemple, les pointeurs intelligents) sont cruciales.
• Ada : Historiquement utilisé dans les domaines critiques pour la sécurité comme l'aérospatiale et la défense, Ada est réputé pour son typage fort, ses fonctionnalités de concurrence intégrées et son accent sur la fiabilité. Sa pertinence pour les systèmes embarqués en temps réel le rend pertinent pour certaines applications robotiques.
• Langages de programmation fonctionnelle (par exemple, Haskell, F#) : Bien que moins courants pour le contrôle de robot de bas niveau en raison des limitations de performances ou d'écosystème, les langages avec un typage statique fort et souvent inféré, ainsi que des fonctionnalités comme l'immuabilité et des systèmes de types puissants, peuvent être excellents pour la planification, la simulation ou les tâches de vérification formelle de niveau supérieur.

La décision implique également de prendre en compte l'écosystème plus large : les bibliothèques disponibles pour les interfaces matérielles, les intergiciels (comme ROS - Robot Operating System), les outils de simulation et la disponibilité de développeurs expérimentés dans un langage particulier.

Avantages de la robotique à typage sûr

L'adoption de pratiques à typage sûr dans le contrôle des robots offre de nombreux avantages :

• Réduction des erreurs d'exécution : L'avantage le plus important est la réduction drastique des bogues liés aux types qui se manifesteraient autrement par des plantages ou un comportement inattendu au moment de l'exécution, en particulier dans des conditions exigeantes.
• Amélioration de la qualité et de la lisibilité du code : Les types explicites rendent le code plus auto-documenté et plus facile à comprendre, ce qui améliore la maintenabilité et la collaboration entre les équipes de développement mondiales.
• Amélioration de la maintenabilité : Le code bien typé est moins sujet aux régressions lorsque des modifications sont apportées. Le compilateur peut aider à identifier l'impact des modifications dans l'ensemble du code.
• Augmentation de la productivité des développeurs : Bien que le développement initial puisse sembler plus lent en raison d'une vérification des types plus stricte, le temps gagné en débogage augmente considérablement la productivité globale à long terme.
• Amélioration de la fiabilité et de la sécurité du système : Pour les systèmes critiques pour la sécurité, la sécurité des types n'est pas seulement une bonne pratique de développement ; c'est une exigence fondamentale pour assurer un fonctionnement sûr.
• Facilite la vérification formelle : Un système de types bien défini fournit une base solide pour l'application de techniques de vérification formelle.

Défis et considérations

La mise en œuvre de la robotique à typage sûr n'est pas sans défis :

• Courbe d'apprentissage : Les développeurs habitués aux langages dynamiques peuvent faire face à une courbe d'apprentissage lors de l'adoption de langages avec un typage statique fort et des fonctionnalités avancées du système de types.
• Surcharge de performances (perçue) : Bien que le typage statique lui-même améliore généralement les performances en permettant des optimisations, la rigueur peut nécessiter des annotations de type plus explicites ou une conception soignée pour éviter un code verbeux.
• Systèmes hérités et interopérabilité : L'intégration de composants à typage sûr dans des systèmes hérités existants écrits dans des langages moins sûrs en matière de types peut être complexe, nécessitant une conception d'interface soignée et potentiellement un code de pontage.
• Expressivité vs. Rigueur : Les systèmes de types extrêmement stricts peuvent parfois rendre difficile l'expression de certains comportements dynamiques ou la gestion de données très hétérogènes sans recourir à une programmation complexe au niveau du type.
• Prise en charge des outils : La disponibilité et la maturité des compilateurs, des outils d'analyse statique et de la prise en charge des IDE pour des langages spécifiques et des fonctionnalités de sécurité des types peuvent varier.

Informations exploitables pour les développeurs mondiaux

Pour les développeurs et les équipes travaillant sur des systèmes robotiques dans le monde entier, tenez compte de ces étapes concrètes :

1. Prioriser les langages avec un typage statique fort : Pour les nouveaux projets, envisagez fortement des langages comme Rust, C++ (avec les normes modernes) ou Ada, en particulier pour la logique de contrôle de base.
2. Investir dans des types spécifiques au domaine : Définissez et utilisez activement des types qui reflètent les concepts physiques et logiques de votre système robotique. Ne traitez pas toutes les valeurs `f64` de la même manière.
3. Tirer parti des bibliothèques compatibles avec les unités : Explorez et intégrez des bibliothèques qui fournissent un suivi des unités ou une analyse dimensionnelle au moment de la compilation lorsque cela est possible.
4. Adopter des avertissements de compilateur stricts : Configurez votre système de build pour traiter tous les avertissements du compilateur comme des erreurs. Cela oblige les développeurs à résoudre les problèmes potentiels tôt.
5. Utiliser des outils d'analyse statique : Intégrez des outils d'analyse statique dans votre pipeline CI/CD pour détecter un large éventail de bogues et de vulnérabilités potentielles.
6. Éduquer votre équipe : Assurez-vous que tous les membres de l'équipe comprennent les principes de la sécurité des types et les fonctionnalités spécifiques du système de types que vous utilisez.
7. Commencer petit et itérer : Si vous migrez un projet existant, commencez par introduire la sécurité des types dans les modules critiques ou les nouvelles fonctionnalités, puis étendez progressivement.
8. Documenter les définitions de types : Documentez clairement l'objectif et les contraintes attendues des types personnalisés pour faciliter la compréhension entre les équipes internationales.
9. Adopter des méthodes formelles pour les composants critiques : Pour les fonctions hautement critiques pour la sécurité, étudiez la faisabilité de l'application de techniques de vérification formelle.
10. Choisir judicieusement un intergiciel : Si vous utilisez un intergiciel comme ROS, explorez comment ses mécanismes de sérialisation des messages et de vérification des types peuvent compléter la sécurité des types de votre système.

Conclusion

La robotique à typage sûr n'est pas simplement un concept théorique ; c'est une nécessité pratique pour construire la prochaine génération de systèmes robotiques fiables, sûrs et prévisibles. En mettant en œuvre des systèmes de types robustes et en employant des techniques d'analyse statique avancées, les développeurs peuvent réduire considérablement l'incidence d'erreurs coûteuses et dangereuses. Alors que la robotique continue de s'immiscer dans toutes les facettes de notre société mondiale, des usines automatisées aux dispositifs médicaux intelligents en passant par le transport autonome, l'engagement envers la conception et la mise en œuvre à typage sûr sera un différenciateur clé pour le succès et la fiabilité.

L'adoption de principes à typage sûr permet aux ingénieurs de créer des robots qui non seulement effectuent leurs tâches efficacement, mais fonctionnent également avec le plus haut degré de confiance et d'intégrité, ce qui en fait des partenaires vraiment fiables dans notre monde de plus en plus automatisé.